//! `std::slice` 排序功能示例
//!
//! `sortx` 模块演示了如何对切片进行排序，包括稳定排序和不稳定排序。

/// # 切片排序示例
///
/// 这个函数展示了 `sort` 和 `sort_by` 等排序方法的用法。
#[test]
pub fn stdx_slice_sort_examples() {
    // --- `sort()`: 不稳定排序 ---
    let mut numbers = [5, 2, 8, 1, 9];
    numbers.sort(); // 使用不稳定排序算法对切片进行升序排序
    println!("`sort()` 后的切片: {:?}", numbers);
    assert_eq!(numbers, [1, 2, 5, 8, 9]);

    // --- `sort_unstable()`: 显式使用不稳定排序 ---
    let mut numbers_unstable = [5, 2, 8, 1, 9];
    numbers_unstable.sort_unstable(); // 效果同 `sort()`
    println!("`sort_unstable()` 后的切片: {:?}", numbers_unstable);
    assert_eq!(numbers_unstable, [1, 2, 5, 8, 9]);

    // --- `sort_by()`: 自定义排序逻辑 ---
    let mut numbers_custom = [5, 2, 8, 1, 9];
    // 按降序排序
    numbers_custom.sort_by(|a, b| b.cmp(a));
    println!("`sort_by()` 降序排序后的切片: {:?}", numbers_custom);
    assert_eq!(numbers_custom, [9, 8, 5, 2, 1]);

    // --- `sort_by_key()`: 根据键进行排序 ---
    let mut strings = ["rust", "is", "awesome"];
    // 按字符串长度排序
    strings.sort_by_key(|s| s.len());
    println!("`sort_by_key()` 按长度排序后的切片: {:?}", strings);
    assert_eq!(strings, ["is", "rust", "awesome"]);

    // --- `sort_stable()`: 稳定排序 ---
    // 稳定排序保证相等元素的相对顺序不变。
    // 例如，我们有一个元组列表 (id, value)，我们想按 id 排序。
    let mut pairs = vec![(2, "b"), (1, "a"), (2, "c")];
    // 使用不稳定排序，(2, "b") 和 (2, "c") 的顺序不确定
    // pairs.sort_by_key(|k| k.0);

    // 使用稳定排序，(2, "b") 会保持在 (2, "c") 之前
    pairs.sort_by_key(|k| k.0);
    println!("`sort_stable_by_key()` 后的切片: {:?}", pairs);
    assert_eq!(pairs, vec![(1, "a"), (2, "b"), (2, "c")]);

    // --- 对浮点数排序 ---
    let mut floats = [5.5, 1.1, -3.3, 8.8];
    // `sort` 不能直接用于浮点数，因为浮点数没有实现 `Ord` trait (NaN 的问题)
    // 需要使用 `sort_by` 和 `partial_cmp`
    floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
    println!("排序后的浮点数切片: {:?}", floats);
    assert_eq!(floats, [-3.3, 1.1, 5.5, 8.8]);
}
// `std::slice::iter` 模块的功能示例
// `iterx` 模块演示了如何使用切片的各种迭代器。

/// # 切片迭代器示例
///
/// 这个函数展示了 `iter`, `iter_mut`, `chunks`, `windows` 等迭代器的用法。
#[test]
pub fn stdx_slice_iter_examples() {
    let slice = &[1, 2, 3, 4, 5, 6];

    // --- `iter()`: 创建一个不可变引用的迭代器 ---
    println!("使用 `iter()` 遍历切片:");
    for item in slice.iter() {
        print!("{} ", item);
    }
    println!(); // 换行

    // --- `iter_mut()`: 创建一个可变引用的迭代器 ---
    let mut mutable_slice = &mut [10, 20, 30];
    println!("\n使用 `iter_mut()` 修改切片元素:");
    for item in mutable_slice.iter_mut() {
        *item *= 2; // 将每个元素乘以 2
    }
    println!("修改后的切片: {:?}", mutable_slice);

    // --- `windows()`: 创建一个滑动窗口迭代器 ---
    println!("\n使用 `windows(3)` 创建大小为 3 的滑动窗口:");
    for window in slice.windows(3) {
        println!("{:?}", window);
    }
    // 输出:
    // [1, 2, 3]
    // [2, 3, 4]
    // [3, 4, 5]
    // [4, 5, 6]

    // --- `chunks()`: 创建一个固定大小块的迭代器 ---
    println!("\n使用 `chunks(2)` 创建大小为 2 的块:");
    for chunk in slice.chunks(2) {
        println!("{:?}", chunk);
    }
    // 输出:
    // [1, 2]
    // [3, 4]
    // [5, 6]

    // --- `chunks_mut()`: 创建可变的固定大小块迭代器 ---
    let mut mutable_slice_for_chunks = &mut [1, 2, 3, 4, 5, 6];
    println!("\n使用 `chunks_mut(3)` 修改每个块:");
    for chunk in mutable_slice_for_chunks.chunks_mut(3) {
        chunk.reverse(); // 反转每个块
    }
    println!("修改后的切片: {:?}", mutable_slice_for_chunks); // [3, 2, 1, 6, 5, 4]

    // --- `split()`: 根据条件将切片分割成子切片 ---
    let split_slice = &[1, 2, 0, 3, 4, 0, 5];
    println!("\n使用 `split()` 按 0 分割切片:");
    for sub_slice in split_slice.split(|&x| x == 0) {
        println!("{:?}", sub_slice);
    }
    // 输出:
    // [1, 2]
    // [3, 4]
    // [5]
}
